
#include "../../BSTree/Node.h"
#include "../../Conf/Configuration.h"
#include "../../Conf/CodigoArbol.h"

using namespace std;

	Node::Node(unsigned int refNodo, unsigned int nivel, Clave* clave, unsigned short tamanio)
	{
		this->refNodo = refNodo;
		this->nivel   = nivel;
		this->tamanio = tamanio;
		this->posicionEnArchivo = 1;

		this->setEspacioLibre(tamanio - this->getTamanioHeader());

		/*Agrega la clave a la lista de claves del Node*/
		this->keyNode = new KeyNode();
		this->keyNode->insert(clave);
		this->actualizarEspacioLibre(clave, true);
	}

	Node::Node(unsigned int refNodo, unsigned int nivel, unsigned short tamanio)
	{
		this->refNodo = refNodo;
	    this->nivel=nivel;
	    this->tamanio = tamanio;
	    this->posicionEnArchivo = 1;

		this->setEspacioLibre(tamanio - this->getTamanioHeader());

	    this->keyNode = new KeyNode();
	}

	Node::Node(){
		this->espacioLibre = this->getTamanio();
	}

	Node::~Node()
	{
		if(keyNode)
			delete this->keyNode;
	}

	unsigned short Node::getTamanioEspacioClaves(){

		if (this->getPosicionEnArchivo() == 0) { //Nodo raíz
			unsigned short espacioClaves = 4*(this->getTamanio()/2 - this->getTamanioHeader() + Tamanios::TAMANIO_REFERENCIA)/3;

			if (this->getNivel() == 0)
				return (espacioClaves + Tamanios::TAMANIO_REFERENCIA);
			else return espacioClaves;
		}

		if (this->getNivel() == 0) //Nodo hoja ==> Tengo que sumarle el espacio que se le descuenta por la referencia al hijo izq
			return (this->getTamanio() - this->getTamanioHeader() + Tamanios::TAMANIO_REFERENCIA);
		else return (this->getTamanio() - this->getTamanioHeader());

	}

	Clave* Node::buscar(Clave* claveBuscada)
	{
		return this->getKeyNode()->findClave(claveBuscada);
	}

	Clave* Node::buscarSiguiente(Clave* claveBuscada)
	{
		return this->getKeyNode()->findClaveSiguiente(claveBuscada);
	}

	bool Node::reemplazarClave(Clave* claveVieja, Clave* claveNueva, char* codigo)
	{
		Clave* claveBuscada = this->buscar(claveVieja);

		if ((!claveBuscada) || (!(*claveBuscada == *claveVieja))) return false;

		this->eliminarClave(claveVieja, codigo);

		this->insertarClave(claveNueva, codigo);

		return true;
	}



	unsigned short Node::getTamanioEnDiscoKeyNode(){

		//Calcula el tamanio que ocupa el conjunto de claves dentro del nodo
		unsigned short tamanio = 0;

		KeyNode::iterator iter;
		for (iter = this->getKeyNode()->begin(); iter != this->getKeyNode()->end(); ++iter){
			tamanio += (*iter)->getTamanioEnDisco();
		}

		return tamanio;

	}


	unsigned short Node::bytesACeder(unsigned short bytesRequeridos, unsigned char &clavesPropuestas,
									 bool izquierda){

		unsigned short sumaBytesRequeridos = 0;
		unsigned short tamanioEnDiscoKeyNode = this->getTamanioEnDiscoKeyNode();
		unsigned short tamanioMinimo = this->getTamanioMinimo();
		clavesPropuestas = 0;


		if (izquierda){
			for (KeyNode::iterator iter = this->getKeyNode()->begin();
				(iter != this->getKeyNode()->end()) && (sumaBytesRequeridos < bytesRequeridos) &&
				((tamanioEnDiscoKeyNode - sumaBytesRequeridos) > tamanioMinimo);
				++iter){
				sumaBytesRequeridos += (*iter)->getTamanioEnDisco();
				++clavesPropuestas;
			}
		}
		else{ //if (derecha)
			for (KeyNode::reverse_iterator iter = this->getKeyNode()->rbegin();
				(iter != this->getKeyNode()->rend()) && (sumaBytesRequeridos < bytesRequeridos) &&
				((tamanioEnDiscoKeyNode - sumaBytesRequeridos) > tamanioMinimo);
				++iter){
				sumaBytesRequeridos += (*iter)->getTamanioEnDisco();
				++clavesPropuestas;
			}
		}

		if ( (bytesRequeridos > sumaBytesRequeridos) || ((tamanioEnDiscoKeyNode - sumaBytesRequeridos) < tamanioMinimo) ) return 0;
		else return sumaBytesRequeridos;

	}

	unsigned short Node::bytesACeder(unsigned char clavesPropuestas, bool izquierda){

		unsigned short sumaBytesRequeridos = 0;
		unsigned char i = 0;

		if (this->getKeyNode()->size() < clavesPropuestas) return 0;

		if (izquierda){
			for (KeyNode::iterator iter = this->getKeyNode()->begin();
				(iter != this->getKeyNode()->end()) && (i < clavesPropuestas);
				++iter, ++i){
				sumaBytesRequeridos += (*iter)->getTamanioEnDisco();
			}
		}
		else{ //if (derecha)
			for (KeyNode::reverse_iterator iter = this->getKeyNode()->rbegin();
				(iter != this->getKeyNode()->rend()) && (i < clavesPropuestas);
				++iter, ++i){
				sumaBytesRequeridos += (*iter)->getTamanioEnDisco();
			}
		}

		return sumaBytesRequeridos;

	}

	bool Node::puedeRecibir(unsigned short bytesEntrantes, unsigned short bytesSalientes){

		unsigned short tamanioEspacioClavesResultante = this->getTamanioEnDiscoKeyNode() + bytesEntrantes - bytesSalientes;

		if (bytesEntrantes >= bytesSalientes) {
			return ( tamanioEspacioClavesResultante <=  this->getTamanioEspacioClaves() );
		}
		else{
			//Si este nodo es el nodo raíz, no se verifica underflow
			if (this->getPosicionEnArchivo() == 0) return true;
			return ( tamanioEspacioClavesResultante >= this->getTamanioMinimo() );
		}

	}


	//Devuelve un conjunto con las claves a ceder
	KeyNode* Node::cederBytes(unsigned short bytesRequeridos, bool izquierda) {

		unsigned short sumaBytesRequeridos = 0;

		KeyNode* set = new KeyNode();

		if (izquierda){

			KeyNode::iterator iter;
			for (iter = this->getKeyNode()->begin();
				(iter != this->getKeyNode()->end()) && (sumaBytesRequeridos < bytesRequeridos);
				++iter){
				sumaBytesRequeridos += (*iter)->getTamanioEnDisco();
				set->insert(*iter);
			}

			this->getKeyNode()->erase(this->getKeyNode()->begin(), iter);

		}
		else{ //if (derecha)

			KeyNode::iterator iter;
			for (iter = (--(this->getKeyNode()->end()));
				(iter != this->getKeyNode()->begin()) && (sumaBytesRequeridos < bytesRequeridos);
				--iter){
				sumaBytesRequeridos += (*iter)->getTamanioEnDisco();
				set->insert(*iter);
			}

			this->getKeyNode()->erase(++iter, this->getKeyNode()->end());

		}

		this->actualizarEspacioLibre();
		return set;
	}


	//Si puede ceder devuelve un conjunto con las claves a ceder, sino devuelve NULL.
	KeyNode* Node::cederClaves(unsigned short cantClaves, bool izquierda) {

		unsigned short i = 0, sumaBytesRequeridos = 0;
		KeyNode* set = new KeyNode();

		if (izquierda){

			KeyNode::iterator iter;
			for (iter = this->getKeyNode()->begin();
				(iter != this->getKeyNode()->end()) && (i < cantClaves);
				++iter){
				sumaBytesRequeridos += (*iter)->getTamanioEnDisco();
				set->insert(*iter);
				++i;
			}

			if ( (getTamanioEnDiscoKeyNode() - sumaBytesRequeridos) >= this->getTamanioMinimo() ) {
				this->getKeyNode()->erase(this->getKeyNode()->begin(), iter);
				return set;
			}

		}
		else{ //if (derecha)

			KeyNode::iterator iter;
			for (iter = (--(this->getKeyNode()->end()));
				(iter != this->getKeyNode()->begin()) && (i < cantClaves);
				--iter){
				sumaBytesRequeridos += (*iter)->getTamanioEnDisco();
				set->insert(*iter);
				++i;
			}

			if ( (iter == this->getKeyNode()->begin()) && (i < cantClaves) ) {
				sumaBytesRequeridos += (*iter)->getTamanioEnDisco();
				set->insert(*iter);
			}

			if ( (getTamanioEnDiscoKeyNode() - sumaBytesRequeridos) >= this->getTamanioMinimo() ) {
				this->getKeyNode()->erase(iter, this->getKeyNode()->end());
				return set;
			}
		}

		set->clear();
		delete set;

		return NULL;

	}


	void Node::recibir(KeyNode* set){
		for(KeyNode::iterator iter = set->begin(); iter != set->end(); ++iter){
			this->getKeyNode()->insert(*iter);
		}
		this->actualizarEspacioLibre(set, true);
		set->clear();
	}


	unsigned short Node::obtenerBytesRequeridos(){

		unsigned short bytesOcupados = this->getTamanioEnDiscoKeyNode();

		if (bytesOcupados >= this->getTamanioMinimo()) return 0;

		return (this->getTamanioMinimo() - bytesOcupados);

	}


	unsigned short Node::obtenerBytesSobrantes(unsigned short &cantClaves, bool izquierda){

		unsigned short tamanioEspacioClaves = this->getTamanioEspacioClaves();
		cantClaves = 0;
		unsigned short sumaSobrantes = 0;
		unsigned short tamanioEnDiscoKeyNode = this->getTamanioEnDiscoKeyNode();

		if (izquierda){
			for(KeyNode::iterator iter = this->getKeyNode()->begin(); (tamanioEnDiscoKeyNode - sumaSobrantes) > tamanioEspacioClaves; ++iter){
				++cantClaves;
				sumaSobrantes += (*iter)->getTamanioEnDisco();
			}
		}
		else{ //if (derecha)
			for(KeyNode::reverse_iterator iter = this->getKeyNode()->rbegin(); (tamanioEnDiscoKeyNode - sumaSobrantes) > tamanioEspacioClaves; ++iter){
				++cantClaves;
				sumaSobrantes += (*iter)->getTamanioEnDisco();
			}
		}

		return sumaSobrantes;

	}

	unsigned short Node::obtenerBytesSobreMinimo(bool izquierda){

		unsigned short tamanioEnDiscoKeyNode = this->getTamanioEnDiscoKeyNode();
		unsigned short suma = 0, sumaAnterior = 0;
		unsigned short tamanioMinimo = this->getTamanioMinimo();

		if (izquierda){
			for(KeyNode::iterator iter = this->getKeyNode()->begin(); ( iter != this->getKeyNode()->end() ) && ( (tamanioEnDiscoKeyNode - suma) > tamanioMinimo ); ++iter){
				sumaAnterior = suma;
				suma += (*iter)->getTamanioEnDisco();
			}
		}
		else{ //if (derecha)
			for(KeyNode::reverse_iterator iter = this->getKeyNode()->rbegin(); ( iter != this->getKeyNode()->rend() ) && ( (tamanioEnDiscoKeyNode - suma) > tamanioMinimo ); ++iter){
				sumaAnterior = suma;
				suma += (*iter)->getTamanioEnDisco();
			}
		}

		return sumaAnterior;

	}

	bool Node::esPadre(Node* hijo, Clave* &claveProxNodo, Clave* claveNodoHijo){

		Clave* primeraClaveNodoHijo = hijo->obtenerPrimeraClave();

		if (primeraClaveNodoHijo)
			claveProxNodo = this->buscar(primeraClaveNodoHijo);
		else
			claveProxNodo = this->buscar(claveNodoHijo);

		if ( (claveProxNodo) && (claveProxNodo->getHijoDer() == hijo->getPosicionEnArchivo()) )
			return true;

		if ((!claveProxNodo) && (this->getHijoIzq() == hijo->getPosicionEnArchivo()))
			return true;

		return false;

	}


	Clave* Node::obtenerPrimeraClave(){

		if (this->getKeyNode()->empty()) return NULL;

		return *(this->getKeyNode()->begin());

	}


	Clave* Node::obtenerUltimaClave(){

		if (this->getKeyNode()->empty()) return NULL;

		return *(this->getKeyNode()->rbegin());

	}


	bool Node::puedeRecibirClaveDesdeIzq(Node* nodoHnoIzq, Node* nodoPadre, Clave* clavePadre){

		unsigned short cantClavesSobrantes;
		unsigned short bytesSobrantes = nodoHnoIzq->obtenerBytesSobrantes(cantClavesSobrantes, false);
		//Variable que almacena el tamanio en bytes de las claves sobrantes sin incluir la ultima clave.
		unsigned short primerosBytesSobrantes = nodoHnoIzq->bytesACeder(cantClavesSobrantes - 1, false);
		unsigned short bytesUltimaClaveSobrante = bytesSobrantes - primerosBytesSobrantes;
		unsigned short tamanioClavePadre = clavePadre->getTamanioEnDisco();
		unsigned short tamanioClavePadreARecibir = tamanioClavePadre;

		if (this->getNivel() == 0) {
			tamanioClavePadreARecibir -= Tamanios::TAMANIO_REFERENCIA;
			bytesUltimaClaveSobrante += Tamanios::TAMANIO_REFERENCIA;
		}

		if ( tamanioClavePadreARecibir > this->getEspacioLibre() ) return false;


		if ( (this->puedeRecibir(primerosBytesSobrantes + tamanioClavePadreARecibir, 0))
			&& ( nodoPadre->puedeRecibir(bytesUltimaClaveSobrante, tamanioClavePadre) ) )
			return true;

		return false;
	}


	bool Node::puedeRecibirClaveDesdeDer(Node* nodoHnoDer, Node* nodoPadre, Clave* clavePadre){

		unsigned short cantClavesSobrantes;
		unsigned short bytesSobrantes = nodoHnoDer->obtenerBytesSobrantes(cantClavesSobrantes);
		//Variable que almacena el tamanio en bytes de las claves sobrantes sin incluir la ultima clave.
		unsigned short primerosBytesSobrantes = nodoHnoDer->bytesACeder(cantClavesSobrantes - 1);
		unsigned short bytesUltimaClaveSobrante = bytesSobrantes - primerosBytesSobrantes;
		unsigned short tamanioClavePadre = clavePadre->getTamanioEnDisco();
		unsigned short tamanioClavePadreARecibir = tamanioClavePadre;

		if (this->getNivel() == 0) {
			tamanioClavePadreARecibir -= Tamanios::TAMANIO_REFERENCIA;
			bytesUltimaClaveSobrante += Tamanios::TAMANIO_REFERENCIA;
		}

		if ( tamanioClavePadreARecibir > this->getEspacioLibre() ) return false;

		if ( (this->puedeRecibir(primerosBytesSobrantes + tamanioClavePadreARecibir, 0))
			&& ( nodoPadre->puedeRecibir(bytesUltimaClaveSobrante, tamanioClavePadre) ) )
			return true;

		return false;

	}


	bool Node::puedePasarClaveHaciaIzq(Node* nodoHnoIzq, Node* nodoPadre, Clave* clavePadre){

		//Bytes requeridos por el hermano izquierdo
		unsigned short bytesRequeridos = nodoHnoIzq->obtenerBytesRequeridos();
		unsigned short bytesPropuestosPorMi = 0;
		unsigned short bytesHaciaElPadre = 0;
		unsigned short tamanioClavePadre = clavePadre->getTamanioEnDisco();
		unsigned char clavesPropuestas = 0;
		unsigned short tamanioClavePadreARecibir = tamanioClavePadre;
		Clave* primeraClave = this->obtenerPrimeraClave();
		if (!primeraClave) return false;
		unsigned short tamanioClaveHaciaElPadre = primeraClave->getTamanioEnDisco();

		if (this->getNivel() == 0) {
			tamanioClavePadreARecibir -= Tamanios::TAMANIO_REFERENCIA;
			tamanioClaveHaciaElPadre += Tamanios::TAMANIO_REFERENCIA;
		}

		if ( ( tamanioClavePadreARecibir >= bytesRequeridos ) &&
			 (nodoPadre->puedeRecibir(tamanioClaveHaciaElPadre, tamanioClavePadre)) &&
			 (bytesACeder(this->obtenerPrimeraClave()->getTamanioEnDisco(), clavesPropuestas) > 0) )
			return true;

		bytesRequeridos -= tamanioClavePadreARecibir;
		bytesPropuestosPorMi = this->bytesACeder(bytesRequeridos, clavesPropuestas);

		if ( (bytesPropuestosPorMi > 0)
			&& (nodoHnoIzq->puedeRecibir(bytesPropuestosPorMi + tamanioClavePadreARecibir, 0))
			&& ( (bytesHaciaElPadre = this->bytesACeder(clavesPropuestas + 1)) > 0 ) ) {
				bytesHaciaElPadre -= bytesPropuestosPorMi;
				//Si la clave pasa de un nodo hoja a un nodo interno, el tamaño se incrementa
				//debido a que ahora tendrá una referencia al hijo derecho.
				if (this->getNivel() == 0) bytesHaciaElPadre += Tamanios::TAMANIO_REFERENCIA;
				if ( nodoPadre->puedeRecibir(bytesHaciaElPadre, tamanioClavePadre) )
					return true;
		}

		return false;

	}


	bool Node::puedePasarClaveHaciaDer(Node* nodoHnoDer, Node* nodoPadre, Clave* clavePadre){

		//Bytes requeridos por el hermano derecho
		unsigned short bytesRequeridos = nodoHnoDer->obtenerBytesRequeridos();
		unsigned short bytesPropuestosPorMi = 0;
		unsigned short bytesHaciaElPadre = 0;
		unsigned short tamanioClavePadre = clavePadre->getTamanioEnDisco();
		unsigned char clavesPropuestas = 0;
		unsigned short tamanioClavePadreARecibir = tamanioClavePadre;
		Clave* primeraClave = this->obtenerPrimeraClave();
		if (!primeraClave) return false;
		unsigned short tamanioClaveHaciaElPadre = primeraClave->getTamanioEnDisco();

		if (this->getNivel() == 0) {
			tamanioClavePadreARecibir -= Tamanios::TAMANIO_REFERENCIA;
			tamanioClaveHaciaElPadre += Tamanios::TAMANIO_REFERENCIA;
		}

		if ( ( tamanioClavePadreARecibir >= bytesRequeridos ) &&
			 (nodoPadre->puedeRecibir(tamanioClaveHaciaElPadre, tamanioClavePadre)) &&
			 (bytesACeder(this->obtenerPrimeraClave()->getTamanioEnDisco(), clavesPropuestas, false) > 0) )
			return true;

		bytesRequeridos -= tamanioClavePadreARecibir;
		bytesPropuestosPorMi = this->bytesACeder(bytesRequeridos, clavesPropuestas, false);

		if ( (bytesPropuestosPorMi > 0)
			&& (nodoHnoDer->puedeRecibir(bytesPropuestosPorMi + tamanioClavePadreARecibir, 0))
			&& ( (bytesHaciaElPadre = this->bytesACeder(clavesPropuestas + 1, false)) > 0 ) ){
				bytesHaciaElPadre -= bytesPropuestosPorMi;
				//Si la clave pasa de un nodo hoja a un nodo interno, el tamaño se incrementa
				//debido a que ahora tendrá una referencia al hijo derecho.
				if (this->getNivel() == 0) bytesHaciaElPadre += Tamanios::TAMANIO_REFERENCIA;
				if ( nodoPadre->puedeRecibir(bytesHaciaElPadre, tamanioClavePadre) )
					return true;
			}

		return false;

	}


	void Node::merge(Node* nodoHno, Clave* clavePadre) {

		return this->getKeyNode()->merge(nodoHno->getKeyNode(), clavePadre, NULL);
	}


	void Node::merge(Node* nodoHno1, Node* nodoHno2, Clave* clavePadre1, Clave* clavePadre2) {

		return this->getKeyNode()->merge(nodoHno1->getKeyNode(), nodoHno2->getKeyNode(), clavePadre1, clavePadre2);
	}

	Clave* Node::extraerUltimaClave(){
		if (this->getKeyNode()->empty()) return NULL;
		KeyNode::iterator iter = this->getKeyNode()->end();
		Clave* clave = *(--iter);
		this->getKeyNode()->erase(iter);
		this->actualizarEspacioLibre(clave, false);
		return clave;
	}

	Clave* Node::extraerPrimeraClave() {
		if (this->getKeyNode()->empty()) return NULL;
		KeyNode::iterator iter = this->getKeyNode()->begin();
		Clave* clave = *iter;
		this->getKeyNode()->erase(iter);
		this->actualizarEspacioLibre(clave, false);
		return clave;
	}

	void Node::extraerClave(Clave* clave) {
		KeyNode::iterator iter = this->getKeyNode()->find(clave);
		if (iter == this->getKeyNode()->end()) return;
		this->getKeyNode()->erase(iter);
		this->actualizarEspacioLibre(clave, false);
	}


	bool Node::tieneOverflow(){
		return (this->getTamanioEnDiscoKeyNode() > this->getTamanioEspacioClaves());
	}


	bool Node::tieneUnderflow(){
		return (this->getTamanioEnDiscoKeyNode() < this->getTamanioMinimo());
	}


	KeyNode* Node::splitB(unsigned short minClaves) {
		KeyNode* set = this->getKeyNode()->splitBSharp(minClaves, this->getTamanioEspacioClaves(), this->getNivel() == 0);
		this->actualizarEspacioLibre();
		return set;
	}


	void Node::insertarClave(Clave* &clave, char* codigo)
	{
		char cod = CodigoArbol::NO_MODIFICADO;

		//Se verifica si la clave está en el conjunto
		if (this->getKeyNode()->find(clave) != this->getKeyNode()->end()) {
			*codigo = cod;
			return;
		}

		//Insercion ordenada de la clave en el keyNode
		this->getKeyNode()->insert(clave);

		//Si hay espacio suficiente para la nueva clave
		if (this->getEspacioLibre() >= clave->getTamanioEnDisco()){
			this->actualizarEspacioLibre(clave, true);
			cod = CodigoArbol::MODIFICADO;
		}else{ //No hay espacio libre suficiente para insertar la clave...
			 cod = CodigoArbol::OVERFLOWARBOL;
		}

		*codigo = cod;
	}


	void Node::eliminarClave(Clave* clave, char* codigo) {

		KeyNode* set = this->getKeyNode();
		KeyNode::iterator iter = set->find(clave);

		if (iter != set->end()) { //Se encontró la clave

			//Se actualiza el espacio libre del nodo
			this->actualizarEspacioLibre(clave, false);

			//Se libera la memoria utilizada por la clave
			delete *iter;
			//Se elimina el puntero a la clave que estaba dentro del conjunto
			set->erase(iter);

			if (this->getTamanioEnDiscoKeyNode() < this->getTamanioMinimo())
				*codigo = CodigoArbol::UNDERFLOWARBOL;
			else
		 		*codigo = CodigoArbol::MODIFICADO;

		} else
			*codigo = CodigoArbol::NO_MODIFICADO;

	}


	void Node::setKeyNode(KeyNode* keyNode)
	{
		if (this->keyNode)
			delete this->keyNode;
		this->keyNode = keyNode;
		this->actualizarEspacioLibre();
	}


	//Método que carga en este nodo todos los mismos valores que posee el nodo pasado por parámetro
	Node& Node::operator = (Node &nodo) {

		this->setHijoIzq(nodo.getHijoIzq());
		this->setNivel(nodo.getNivel());
		this->setTamanio(nodo.getTamanio());

		KeyNode* keyNodeCopia = new KeyNode();
		*keyNodeCopia = *(nodo.getKeyNode());
		this->setKeyNode(keyNodeCopia);

		this->setPosicionEnArchivo(nodo.getPosicionEnArchivo());
		this->setEspacioLibre(nodo.getEspacioLibre());

		return *this;

	}


	void Node::actualizarEspacioLibre(Clave* clave, bool insercion)
	{
		if (insercion)
			this->setEspacioLibre(this->getEspacioLibre() - clave->getTamanioEnDisco());
		else
		   	this->setEspacioLibre(this->getEspacioLibre() + clave->getTamanioEnDisco());
	}

	void Node::actualizarEspacioLibre(KeyNode* claves, bool insercion)
	{
		unsigned int suma = 0;

		for (KeyNode::iterator iter = claves->begin(); iter != claves->end(); ++iter){
			suma += (*iter)->getTamanioEnDisco();
		}

		if (insercion)
			this->setEspacioLibre(this->getEspacioLibre() - suma);
		else
			this->setEspacioLibre(this->getEspacioLibre() + suma);
	}


	void Node::actualizarEspacioLibre() {

		unsigned int espacioLibre = this->getTamanioEspacioClaves();

		for (KeyNode::iterator iter = this->getKeyNode()->begin(); iter != this->getKeyNode()->end(); ++iter) {
			espacioLibre -= (*iter)->getTamanioEnDisco();
		}

		this->setEspacioLibre(espacioLibre);

	}

